////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  aecmetering.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AECMETERING_H
#define AECMETERING_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "globalelements.h"
#include "aecglobalelements.h"

#define AECMETERING_NAMESPACE_BEGIN namespace aecMetering {
#define AECMETERING_NAMESPACE_END }

AECMETERING_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// EVLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct EVLumaTargetType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepsPerEV
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Number of steps for each full EV (1 stop) in the EVCompTable.
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32       stepsPerEV;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minEVValue
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   minimal EV values (starting point) in the EVCompTable.
    /// Range:         [-3,0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32       minEVValue;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxEVValue
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   maximal EV values (ending point) in the EVCompTable.
    /// Range:         [0,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32       maxEVValue;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// EVCompTable
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Luma target scaling ratios for the particular EV value.
    /// Range:         [0, 5]
    /// Length:        49
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct EVCompTableStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// EVCompTableElements - Array
        ///
        /// Tuning Level:  rarely_tune
        /// Length:        49
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT EVCompTableElements[49];
    } EVCompTable;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ExtrmClrLumaTargetZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ExtrmClrLumaTargetZoneDataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// channelAdjRatio - Array
    ///
    /// Tuning Level:  often_tune
    /// Description:   Target adjustment ratio for each color channel in the sequence of R/G/B.
    /// Range:         [0.4,1.0]
    /// Length:        3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT channelAdjRatio[3];
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ExtrmClrLumaTargetZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ExtrmClrLumaTargetZoneType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::TriggerPointType               zoneTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrLumaTargetZoneDataType zoneData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ExtrmClrThresRangeType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ExtrmClrThresRangeType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thres
    ///
    /// Tuning Level:  often_tune
    /// Description:   Threshold for determining if color ratios (rg, bg) is extreme.
    /// Range:         [0,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT thres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// interpPct
    ///
    /// Tuning Level:  often_tune
    /// Description:   Interpolation percentage (extends both direction from thres) to make stable transition in detection.
    /// Range:         [0,0.2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT interpPct;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ExtrmClrLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ExtrmClrLumaTargetType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableExtrmClr
    ///
    /// Tuning Level:  often_tune
    /// Description:   Flag to enable extreme color luma target adjustment.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                        enableExtrmClr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresRed
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Threshold on RG ratio to determine if a stats is red.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrThresRangeType      thresRed;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresGreenR
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Threshold on RG ratio to determine if a stats is green.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrThresRangeType      thresGreenR;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresGreenB
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Threshold on BG ratio to determine if a stats is green.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrThresRangeType      thresGreenB;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresGreenCenter
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Threshold on RG/BG jointly to determine if a stats is green.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrThresRangeType      thresGreenCenter;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBlue
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Threshold on BG ratio to determine if a stats is blue.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrThresRangeType      thresBlue;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresColorStatsPct
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   A range in terms of percentage of color stats to determine whether to apply full target adjustment, or no
    ///                target adjustment.
    /// Range:         [0.0,1.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType                thresColorStatsPct;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresLumaLow
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Effect of the color stats is discounted if the luma value is below the said threshold.
    /// Range:         [0,25]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                       thresLumaLow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresLumaHigh
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Effect of the color stats is discounted if the luma value is above the said threshold.
    /// Range:         [150,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                       thresLumaHigh;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// extrmClrLumaTargetZone - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                      extrmClrLumaTargetZoneCount;
    UINT32                      extrmClrLumaTargetZoneID;
    ExtrmClrLumaTargetZoneType* extrmClrLumaTargetZone;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// HistLumaTargetZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct HistLumaTargetZoneDataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minTargetAdjRatio
    ///
    /// Tuning Level:  often_tune
    /// Description:   Minimal target adjust ratio for safe exposure.
    /// Range:         [0.6, 1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        minTargetAdjRatio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxTargetAdjRatio
    ///
    /// Tuning Level:  often_tune
    /// Description:   Maximal target adjust ratio for safe exposure.
    /// Range:         [1.0, 2.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        maxTargetAdjRatio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// satRefLow
    ///
    /// Tuning Level:  often_tune
    /// Description:   Saturation low reference point, which sets the minimal brightness for saturation position.
    /// Range:         [100,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        satRefLow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// satRefHigh
    ///
    /// Tuning Level:  often_tune
    /// Description:   Saturation high reference point, which sets the maximal brightness for saturation position.
    /// Range:         [100,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        satRefHigh;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// darkRefLow
    ///
    /// Tuning Level:  often_tune
    /// Description:   Dark low reference point, which sets the minimal brightness for dark position.
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        darkRefLow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// darkRefHigh
    ///
    /// Tuning Level:  never_tune
    /// Description:   This one is not recommended to be used.
    /// Range:         [100,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        darkRefHigh;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histSatPushupRange - Array
    ///
    /// Description:   The percentage range of pixels to be used to calculate saturation position for push up (flat scene
    ///                compensation). R/G/B channels get to specify independent ranges.
    /// Range:         [0.0,0.5]
    /// Length:        3
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType histSatPushupRange[3];

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histSatPushdownRange - Array
    ///
    /// Description:   The percentage range of pixels to be used to calculate saturation position for push down (saturation
    ///                prevention). R/G/B channels get to specify independent ranges.
    /// Range:         [0.0,0.5]
    /// Length:        3
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType histSatPushdownRange[3];

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histDarkRange - Array
    ///
    /// Description:   The percentage range of pixels to be used to calculate dark position. R/G/B channels get to specify
    ///                independent ranges.
    /// Range:         [0.0,0.5]
    /// Length:        3
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType histDarkRange[3];

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxDRCGain
    ///
    /// Tuning Level:  often_tune
    /// Description:   This parameter determines the max ratio between long and short exposure.
    /// Range:         [1,16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        maxDRCGain;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// HistLumaTargetZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct HistLumaTargetZoneType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::TriggerPointType           zoneTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    HistLumaTargetZoneDataType zoneData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// HistLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct HistLumaTargetType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableHistMetering
    ///
    /// Tuning Level:  often_tune
    /// Description:   Flag to enable histogram luma target calculation.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                    enableHistMetering;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableADRC
    ///
    /// Tuning Level:  often_tune
    /// Description:   Setting this flag enables ADRC.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                    enableADRC;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableNonLinearTargetEstimate
    ///
    /// Tuning Level:  often_tune
    /// Description:   Enable for histogram AEC to converge faster
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                    enableNonLinearTargetEstimate;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableDarkBoost
    ///
    /// Tuning Level:  often_tune
    /// Description:   Setting this flag enables boosting dark area with tone mapping. ADRC enable is pre-requisite.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                    enableDarkBoost;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableAntiBandingPrioOverADRC
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Setting this flag makes sure antibanding range is not reduced with ADRC enabled.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                    enableAntiBandingPrioOverADRC;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// antiBandingPrioTriggerRange
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   The index range to gradually allow ADRC to regain full allowance when antibanding becomes unavailable due
    ///                to scene brightness.
    /// Range:         [0,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                   antiBandingPrioTriggerRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// targetFilterFactor
    ///
    /// Tuning Level:  never_tune
    /// Description:   Luma target filter factor for this feature.
    /// Range:         [0,0.99]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                   targetFilterFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histLumaTargetZone - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                  histLumaTargetZoneCount;
    UINT32                  histLumaTargetZoneID;
    HistLumaTargetZoneType* histLumaTargetZone;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AECLumaTargetType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luxLumaTarget
    ///
    /// Description:   Luma target tuning structure, which is shared between normal and flash use case.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::LuxLumaTargetType      luxLumaTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histLumaTarget
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    HistLumaTargetType     histLumaTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// extrmClrLumaTarget
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExtrmClrLumaTargetType extrmClrLumaTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// EVLumaTarget
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    EVLumaTargetType       EVLumaTarget;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RgnAdjZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RgnAdjZoneDataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBrightRgn
    ///
    /// Tuning Level:  often_tune
    /// Description:   Threshold pair to determine if a region is bright.
    /// Range:         [0,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::TriggerPointType thresBrightRgn;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresDarkRgn
    ///
    /// Tuning Level:  often_tune
    /// Description:   Threshold pair to determine if a region is dark.
    /// Range:         [0,255]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType     thresDarkRgn;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weightBrightRgnAdj
    ///
    /// Tuning Level:  often_tune
    /// Description:   Additional weight to be applied to a bright region.
    /// Range:         [0, 2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            weightBrightRgnAdj;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weightDarkRgnAdj
    ///
    /// Tuning Level:  often_tune
    /// Description:   Additional weight to be applied to a dark region.
    /// Range:         [0,1.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            weightDarkRgnAdj;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RgnAdjZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RgnAdjZoneType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::TriggerPointType   zoneTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    RgnAdjZoneDataType zoneData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RgnAdjType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RgnAdjType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableBrightRgnAdj
    ///
    /// Tuning Level:  often_tune
    /// Description:   Enable adjustment of weights on bright stats region in luma calculation.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL            enableBrightRgnAdj;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableDarkRgnAdj
    ///
    /// Tuning Level:  often_tune
    /// Description:   Enable adjustment of weights on dark stats region in luma calculation.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL            enableDarkRgnAdj;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minTableWeightForBright
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Minimum metering table weight for bright region adjustment.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT           minTableWeightForBright;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxStatsPctForBright
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Maximum percentage of bright stats that can be weight adjusted.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT           maxStatsPctForBright;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minTableWeightForDark
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Minimum metering table weight for dark region adjustment.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT           minTableWeightForDark;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxStatsPctForDark
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Maximum percentage of dark stats that can be weight adjusted.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT           maxStatsPctForDark;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// rgnAdjZone - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32          rgnAdjZoneCount;
    UINT32          rgnAdjZoneID;
    RgnAdjZoneType* rgnAdjZone;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// MtrTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct MtrTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// centerWeighted
    ///
    /// Tuning Level:  often_tune
    /// Description:   Center weighted metering weight table.
    /// Range:         [0,1]
    /// Length:        256
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct centerWeightedStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// weights - Array
        ///
        /// Tuning Level:  often_tune
        /// Length:        256
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT weights[256];
    } centerWeighted;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// spotWeighted
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Spot metering weight table.
    /// Range:         [0,1]
    /// Length:        256
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct spotWeightedStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// weights - Array
        ///
        /// Tuning Level:  rarely_tune
        /// Length:        256
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT weights[256];
    } spotWeighted;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LumaWeightType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LumaWeightType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weight - Array
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   An array of 3 elements in the sequence of R,G,B weights for luma computation.
    /// Range:         [0, 1]
    /// Length:        3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT weight[3];

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableColorAndSensorComp
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable usage of AWB gain to compensate module and illumination difference.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL  enableColorAndSensorComp;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// refGain - Array
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Reference AWB gain used to adjust luma computation weights.
    /// Range:         [0, 3]
    /// Length:        3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT refGain[3];
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// IndexCalcType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct IndexCalcType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableLuxIndexComp
    ///
    /// Tuning Level:  often_tune
    /// Description:   The flag enables lux index normalization across different sensor modes and headers.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                    enableLuxIndexComp;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// refSensitivityForExpIndexZero
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   The reference sensitivity value which is used to compare with the current table sensitivity at index 0.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                   refSensitivityForExpIndexZero;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luxIndexFilterFactor
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Temporal filter factor for lux index to stabilize its value.
    /// Range:         [0,0.99]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                   luxIndexFilterFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// bayerGridSubsmplSelect
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::AECBayerGridSubsmplType bayerGridSubsmplSelect;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECLumaCalcType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AECLumaCalcType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// indexCalc
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    IndexCalcType  indexCalc;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lumaWeight
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    LumaWeightType lumaWeight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mtrTables
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    MtrTableType   mtrTables;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lumaRgnAdj
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    RgnAdjType     lumaRgnAdj;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECCoreMeteringType
/// Comments:       Core Metering Tuning Definition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AECCoreMeteringType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
        INT32 incr_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mtrLumaCalc
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECLumaCalcType   mtrLumaCalc;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mtrLumaTarget
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECLumaTargetType mtrLumaTarget;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECCoreMeteringTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class AECCoreMeteringTypeClass : public ParameterModule, public AECCoreMeteringType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 1;
    static const UINT16 MINOR = 0;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECCoreMeteringTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECCoreMeteringTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~AECCoreMeteringTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load EVLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadEVLumaTargetType(
        ParameterFileSymbolTableEntry* entry,
        EVLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load EVLumaTargetType_EVCompTableStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadEVLumaTargetType_EVCompTableStruct(
        ParameterFileSymbolTableEntry* entry,
        EVLumaTargetType::EVCompTableStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ExtrmClrLumaTargetZoneDataType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadExtrmClrLumaTargetZoneDataType(
        ParameterFileSymbolTableEntry* entry,
        ExtrmClrLumaTargetZoneDataType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ExtrmClrLumaTargetZoneType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadExtrmClrLumaTargetZoneType(
        ParameterFileSymbolTableEntry* entry,
        ExtrmClrLumaTargetZoneType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ExtrmClrThresRangeType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadExtrmClrThresRangeType(
        ParameterFileSymbolTableEntry* entry,
        ExtrmClrThresRangeType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ExtrmClrLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadExtrmClrLumaTargetType(
        ParameterFileSymbolTableEntry* entry,
        ExtrmClrLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load HistLumaTargetZoneDataType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadHistLumaTargetZoneDataType(
        ParameterFileSymbolTableEntry* entry,
        HistLumaTargetZoneDataType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load HistLumaTargetZoneType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadHistLumaTargetZoneType(
        ParameterFileSymbolTableEntry* entry,
        HistLumaTargetZoneType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load HistLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadHistLumaTargetType(
        ParameterFileSymbolTableEntry* entry,
        HistLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load AECLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadAECLumaTargetType(
        ParameterFileSymbolTableEntry* entry,
        AECLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load RgnAdjZoneDataType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadRgnAdjZoneDataType(
        ParameterFileSymbolTableEntry* entry,
        RgnAdjZoneDataType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load RgnAdjZoneType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadRgnAdjZoneType(
        ParameterFileSymbolTableEntry* entry,
        RgnAdjZoneType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load RgnAdjType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadRgnAdjType(
        ParameterFileSymbolTableEntry* entry,
        RgnAdjType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load MtrTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadMtrTableType(
        ParameterFileSymbolTableEntry* entry,
        MtrTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load MtrTableType_centerWeightedStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadMtrTableType_centerWeightedStruct(
        ParameterFileSymbolTableEntry* entry,
        MtrTableType::centerWeightedStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load MtrTableType_spotWeightedStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadMtrTableType_spotWeightedStruct(
        ParameterFileSymbolTableEntry* entry,
        MtrTableType::spotWeightedStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LumaWeightType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLumaWeightType(
        ParameterFileSymbolTableEntry* entry,
        LumaWeightType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load IndexCalcType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadIndexCalcType(
        ParameterFileSymbolTableEntry* entry,
        IndexCalcType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load AECLumaCalcType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadAECLumaCalcType(
        ParameterFileSymbolTableEntry* entry,
        AECLumaCalcType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load AECCoreMeteringType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadAECCoreMeteringType(
        ParameterFileSymbolTableEntry* entry,
        AECCoreMeteringType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        AECCoreMeteringType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload ExtrmClrLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadExtrmClrLumaTargetType(
        ExtrmClrLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload HistLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadHistLumaTargetType(
        HistLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload AECLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadAECLumaTargetType(
        AECLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload RgnAdjType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadRgnAdjType(
        RgnAdjType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload AECLumaCalcType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadAECLumaCalcType(
        AECLumaCalcType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload AECCoreMeteringType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadAECCoreMeteringType(
        AECCoreMeteringType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class AECCoreMeteringTypeClass

AECMETERING_NAMESPACE_END
#endif // AECMETERING_H

